// 04_flow_control.rs
// 演示 Rust 中的流程控制语句

// 将原来的 main 函数改为公共的 run 函数
pub fn run() {
    // 1. if 表达式
    let number = 7;
    
    if number < 5 {
        println!("{} 小于 5", number);
    } else if number == 5 {
        println!("{} 等于 5", number);
    } else {
        println!("{} 大于 5", number);
    }
    
    // 在表达式中使用 if
    let is_positive = if number > 0 { true } else { false };
    println!("{} 是正数: {}", number, is_positive);
    
    // 注意：if 表达式的每个分支的返回类型必须相同
    let result = if number % 2 == 0 {
        "偶数"
    } else {
        "奇数"
    };
    println!("{} 是 {}", number, result);
    
    // 2. loop 循环
    // loop 创建一个无限循环，直到显式退出
    let mut count = 0;
    
    loop {
        count += 1;
        println!("loop 循环第 {} 次", count);
        
        if count >= 3 {
            println!("达到退出条件，退出 loop 循环");
            break; // 退出循环
        }
    }
    
    // loop 可以带标签，用于嵌套循环中指定要退出的循环
    let mut outer_count = 0;
    'outer: loop {
        outer_count += 1;
        println!("外层循环第 {} 次", outer_count);
        
        let mut inner_count = 0;
        loop {
            inner_count += 1;
            println!("内层循环第 {} 次", inner_count);
            
            if inner_count >= 2 {
                break; // 只退出内层循环
            }
        }
        
        if outer_count >= 2 {
            break 'outer; // 退出带标签的外层循环
        }
    }
    
    // loop 作为表达式可以返回值
    let mut counter = 0;
    let result_value = loop {
        counter += 1;
        
        if counter == 5 {
            break counter * 2; // 退出循环并返回值
        }
    };
    
    println!("loop 表达式返回的值: {}", result_value);
    
    // 3. while 循环
    let mut while_count = 0;
    
    while while_count < 3 {
        println!("while 循环第 {} 次", while_count + 1);
        while_count += 1;
    }
    
    // 4. for 循环
    // for 循环常用于遍历集合
    let numbers = [10, 20, 30, 40, 50];
    
    println!("遍历数组元素:");
    for number in numbers {
        println!("数字: {}", number);
    }
    
    // 使用 range 进行循环
    println!("\n使用 range 1..5:");
    for i in 1..5 {
        println!("range 循环: {}", i); // 1, 2, 3, 4
    }
    
    // 包含上限的 range
    println!("\n使用 range 1..=5:");
    for i in 1..=5 {
        println!("range 循环: {}", i); // 1, 2, 3, 4, 5
    }
    
    // 遍历并修改集合元素（需要 mut 和引用）
    let mut mutable_numbers = [1, 2, 3, 4, 5];
    
    println!("\n修改数组元素:");
    for element in &mut mutable_numbers {
        *element *= 2; // 使用解引用操作符 * 访问和修改值
    }
    
    println!("修改后的数组: {:?}", mutable_numbers);
    
    // 5. match 表达式
    // match 类似于其他语言中的 switch，但功能更强大
    let match_number = 3;
    
    match match_number {
        1 => println!("匹配到 1"),
        2 => println!("匹配到 2"),
        3 => println!("匹配到 3"),
        4 | 5 => println!("匹配到 4 或 5"), // 多个模式用 | 分隔
        6..=10 => println!("匹配到 6 到 10 之间的数"), // 范围模式
        _ => println!("匹配到其他数字"), // 通配符模式，匹配任何值
    }
    
    // match 作为表达式返回值
    let status = match match_number {
        0 => "零",
        1..=9 => "一位数",
        10..=99 => "两位数",
        _ => "多位数",
    };
    
    println!("数字 {} 是 {}", match_number, status);
    
    // 解构元组的 match
    let pair = (2, -2);
    
    match pair {
        (x, y) if x == y => println!("x 和 y 相等: x = y = {}", x),
        (x, y) if x + y == 0 => println!("x 和 y 互为相反数: x = {}, y = {}", x, y),
        (x, y) => println!("x = {}, y = {}", x, y),
    }
}